Mutable and Immutable Strings in Java

In Java, the concept of mutability determines whether an object's state can be modified after it is created. Strings in Java are designed to be immutable, while there are other classes like StringBuilder and StringBuffer that provide mutable string functionality. Here’s a detailed explanation of both:

Immutable Strings

An immutable string is a string whose state cannot be changed after it is created. In Java, the String class represents immutable strings. This immutability offers several benefits, including thread safety and performance optimizations.

Characteristics of Immutable Strings:

1. String Pooling: Java uses a string pool to manage memory efficiently. When a new string is created, the JVM checks the string pool to see if an identical string already exists. If it does, the reference to the existing string is returned instead of creating a new object.
2. Thread Safety: Because strings are immutable, they can be safely shared among multiple threads without synchronization, avoiding potential issues related to concurrent modifications.
3. Security: Immutability ensures that string values cannot be changed, which is important for security purposes, especially when dealing with sensitive data like passwords.
4. Hashcode Caching: The hash code of an immutable string is cached after the first computation, improving performance when strings are used in hash-based collections like HashMap.

Example:

public class ImmutableStringExample {
  public static void main(String[] args) {
    String str = "Hello";
    str = str.concat(" World");
    System.out.println(str); // Outputs: Hello World 
  }
}

In the example above, the concat method creates a new String object rather than modifying the existing one.

Mutable Strings

Mutable strings can be modified after they are created. In Java, StringBuilder and StringBuffer classes provide this functionality. The main difference between the two is that StringBuffer is synchronized (thread-safe), whereas StringBuilder is not.

Characteristics of Mutable Strings:

1. Modifiable: Methods in StringBuilder and StringBuffer modify the internal character array directly, allowing changes to the string's content without creating a new object.
2. Performance: Mutable strings are more efficient for scenarios where frequent modifications are required, as they avoid the overhead of creating new string objects.
3. Thread Safety: StringBuffer provides thread safety by synchronizing its methods, making it suitable for use in multi-threaded environments. StringBuilder should be used in single-threaded contexts for better performance. 

Example with StringBuilder:

public class MutableStringExample {
  public static void main(String[] args) {
    StringBuilder sb = new StringBuilder("Hello");
    sb.append(" World");
    System.out.println(sb.toString()); // Outputs: Hello World 
  }
}

In this example, the append method modifies the original StringBuilder object.

Example with StringBuffer:

public class MutableStringBufferExample {
  public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("Hello");
    sb.append(" World");
    System.out.println(sb.toString()); // Outputs: Hello World 
  }
}

Here, the append method modifies the original StringBuffer object, similar to StringBuilder, but with thread-safe operations.

Summary

Immutable Strings (String):

• Cannot be modified after creation.
• Benefits include string pooling, thread safety, security, and performance optimizations.
• Suitable for strings that do not require frequent modifications.

Mutable Strings (StringBuilder, StringBuffer):

• Can be modified after creation.
• StringBuilder is more efficient but not thread-safe.
• StringBuffer is thread-safe but with additional synchronization overhead.
• Suitable for strings that require frequent modifications.

Understanding the distinction between mutable and immutable strings helps in choosing the right type for your specific use case, ensuring optimal performance and thread safety in Java applications.